const { PrismaClient } = require('@prisma/client');
const bcrypt = require('bcryptjs');
const prisma = new PrismaClient();

/**
 * 获取所有用户
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.getAllUsers = async (req, res) => {
  try {
    // 分开查询用户，避免嵌套查询
    const users = await prisma.user.findMany();
    
    // 提取所有用户的角色和部门ID
    const roleIds = [...new Set(users.map(user => user.roleId))];
    const departmentIds = [...new Set(users.filter(user => user.departmentId).map(user => user.departmentId))];
    
    // 查询角色和部门信息
    const roles = await prisma.Role.findMany({
      where: { id: { in: roleIds } }
    });
    
    const departments = await prisma.Department.findMany({
      where: { id: { in: departmentIds } }
    });
    
    // 创建查找映射
    const roleMap = roles.reduce((map, role) => {
      map[role.id] = role;
      return map;
    }, {});
    
    const departmentMap = departments.reduce((map, dept) => {
      map[dept.id] = dept;
      return map;
    }, {});
    
    // 过滤掉敏感信息并添加角色和部门信息
    const filteredUsers = users.map(user => {
      const { password, ...rest } = user;
      const userRole = roleMap[user.roleId];
      const userDepartment = user.departmentId ? departmentMap[user.departmentId] : null;
      
      return {
        ...rest,
        role: userRole ? userRole.name : null,
        department: userDepartment ? {
          id: userDepartment.id,
          name: userDepartment.name
        } : null
      };
    });
    
    return res.json({
      status: 'success',
      data: filteredUsers
    });
  } catch (error) {
    console.error('获取用户列表失败:', error);
    return res.status(500).json({
      status: 'error',
      message: '获取用户列表失败',
      error: error.message
    });
  }
};

/**
 * 获取单个用户
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.getUserById = async (req, res) => {
  try {
    const { id } = req.params;
    
    // 单独查询用户
    const user = await prisma.user.findUnique({
      where: { id: parseInt(id) }
    });
    
    if (!user) {
      return res.status(404).json({
        status: 'error',
        message: '用户不存在'
      });
    }
    
    // 单独查询角色和部门
    const role = await prisma.Role.findUnique({
      where: { id: user.roleId }
    });
    
    let department = null;
    if (user.departmentId) {
      department = await prisma.Department.findUnique({
        where: { id: user.departmentId }
      });
    }
    
    // 过滤掉敏感信息
    const { password, ...filteredUser } = user;
    
    return res.json({
      status: 'success',
      data: {
        ...filteredUser,
        role: role ? role.name : null,
        department: department ? {
          id: department.id,
          name: department.name
        } : null
      }
    });
  } catch (error) {
    console.error('获取用户失败:', error);
    return res.status(500).json({
      status: 'error',
      message: '获取用户失败',
      error: error.message
    });
  }
};

/**
 * 创建用户
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.createUser = async (req, res) => {
  try {
    const { username, password, name, phone, roleId, departmentId } = req.body;
    
    // 验证必填字段
    if (!username || !password || !roleId) {
      return res.status(400).json({
        status: 'error',
        message: '用户名、密码和角色ID为必填项'
      });
    }
    
    // 检查用户名是否已存在
    const existingUser = await prisma.user.findUnique({
      where: { username }
    });
    
    if (existingUser) {
      return res.status(400).json({
        status: 'error',
        message: '用户名已存在'
      });
    }
    
    // 检查角色是否存在
    const role = await prisma.Role.findUnique({
      where: { id: parseInt(roleId) }
    });
    
    if (!role) {
      return res.status(400).json({
        status: 'error',
        message: '角色不存在'
      });
    }
    
    // 如果提供了部门ID，检查部门是否存在
    if (departmentId) {
      const department = await prisma.Department.findUnique({
        where: { id: parseInt(departmentId) }
      });
      
      if (!department) {
        return res.status(400).json({
          status: 'error',
          message: '部门不存在'
        });
      }
    }
    
    // 加密密码
    const hashedPassword = await bcrypt.hash(password, 10);
    
    // 创建用户
    const newUser = await prisma.user.create({
      data: {
        username,
        password: hashedPassword,
        name,
        phone,
        roleId: parseInt(roleId),
        departmentId: departmentId ? parseInt(departmentId) : null,
        status: true
      }
    });
    
    // 获取角色和部门信息
    const userRole = role;
    let userDepartment = null;
    if (newUser.departmentId) {
      userDepartment = await prisma.Department.findUnique({
        where: { id: newUser.departmentId }
      });
    }
    
    // 过滤掉敏感信息
    const { password: _, ...filteredUser } = newUser;
    
    return res.status(201).json({
      status: 'success',
      message: '用户创建成功',
      data: {
        ...filteredUser,
        role: userRole.name,
        department: userDepartment ? {
          id: userDepartment.id,
          name: userDepartment.name
        } : null
      }
    });
  } catch (error) {
    console.error('创建用户失败:', error);
    return res.status(500).json({
      status: 'error',
      message: '创建用户失败',
      error: error.message
    });
  }
};

/**
 * 更新用户
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.updateUser = async (req, res) => {
  try {
    const { id } = req.params;
    const { username, password, name, phone, roleId, departmentId, status } = req.body;
    
    // 检查用户是否存在
    const user = await prisma.user.findUnique({
      where: { id: parseInt(id) }
    });
    
    if (!user) {
      return res.status(404).json({
        status: 'error',
        message: '用户不存在'
      });
    }
    
    // 如果更改用户名，检查是否已存在
    if (username && username !== user.username) {
      const existingUser = await prisma.user.findUnique({
        where: { username }
      });
      
      if (existingUser) {
        return res.status(400).json({
          status: 'error',
          message: '用户名已存在'
        });
      }
    }
    
    // 如果提供了部门ID，检查部门是否存在
    if (departmentId !== undefined) {
      if (departmentId !== null) {
        const department = await prisma.Department.findUnique({
          where: { id: parseInt(departmentId) }
        });
        
        if (!department) {
          return res.status(400).json({
            status: 'error',
            message: '部门不存在'
          });
        }
      }
    }
    
    // 准备更新数据
    const updateData = {};
    
    if (username) updateData.username = username;
    if (name) updateData.name = name;
    if (phone) updateData.phone = phone;
    if (roleId) updateData.roleId = parseInt(roleId);
    if (status !== undefined) updateData.status = status;
    if (departmentId !== undefined) updateData.departmentId = departmentId ? parseInt(departmentId) : null;
    
    // 如果提供了密码，则加密
    if (password) {
      updateData.password = await bcrypt.hash(password, 10);
    }
    
    // 更新用户
    const updatedUser = await prisma.user.update({
      where: { id: parseInt(id) },
      data: updateData
    });
    
    // 查询更新后的角色和部门
    const role = await prisma.Role.findUnique({
      where: { id: updatedUser.roleId }
    });
    
    let department = null;
    if (updatedUser.departmentId) {
      department = await prisma.Department.findUnique({
        where: { id: updatedUser.departmentId }
      });
    }
    
    // 过滤掉敏感信息
    const { password: _, ...filteredUser } = updatedUser;
    
    return res.json({
      status: 'success',
      message: '用户更新成功',
      data: {
        ...filteredUser,
        role: role.name,
        department: department ? {
          id: department.id,
          name: department.name
        } : null
      }
    });
  } catch (error) {
    console.error('更新用户失败:', error);
    return res.status(500).json({
      status: 'error',
      message: '更新用户失败',
      error: error.message
    });
  }
};

/**
 * 删除用户
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.deleteUser = async (req, res) => {
  try {
    const { id } = req.params;
    
    // 检查用户是否存在
    const user = await prisma.user.findUnique({
      where: { id: parseInt(id) }
    });
    
    if (!user) {
      return res.status(404).json({
        status: 'error',
        message: '用户不存在'
      });
    }
    
    // 删除用户
    await prisma.user.delete({
      where: { id: parseInt(id) }
    });
    
    return res.json({
      status: 'success',
      message: '用户删除成功'
    });
  } catch (error) {
    console.error('删除用户失败:', error);
    return res.status(500).json({
      status: 'error',
      message: '删除用户失败',
      error: error.message
    });
  }
};

/**
 * 解除用户与角色的关联
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.removeRoleFromUser = async (req, res) => {
  try {
    const { userId, roleId } = req.params;
    
    // 检查用户是否存在
    const user = await prisma.user.findUnique({
      where: { id: parseInt(userId) }
    });
    
    if (!user) {
      return res.status(404).json({
        status: 'error',
        message: '用户不存在'
      });
    }
    
    // 检查角色是否存在
    const role = await prisma.role.findUnique({
      where: { id: parseInt(roleId) }
    });
    
    if (!role) {
      return res.status(404).json({
        status: 'error',
        message: '角色不存在'
      });
    }
    
    // 检查用户是否关联了该角色
    if (user.roleId !== parseInt(roleId)) {
      return res.status(400).json({
        status: 'error',
        message: '该用户未关联此角色'
      });
    }
    
    // 获取替代角色（寻找任何其他可用的角色）
    const alternativeRole = await prisma.role.findFirst({
      where: {
        id: {
          not: parseInt(roleId) // 确保不是当前要解除的角色
        }
      }
    });
    
    if (!alternativeRole) {
      return res.status(400).json({
        status: 'error',
        message: '系统中没有其他可用角色，请先创建一个新角色再解除关联'
      });
    }
    
    // 更新用户的角色
    const updatedUser = await prisma.user.update({
      where: { id: parseInt(userId) },
      data: {
        roleId: alternativeRole.id
      },
      include: {
        role: true,
        department: true
      }
    });
    
    // 过滤掉敏感信息
    const { password, ...filteredUser } = updatedUser;
    
    return res.json({
      status: 'success',
      message: `用户与角色"${role.name}"的关联已解除，现已分配到"${alternativeRole.name}"角色`,
      data: {
        ...filteredUser,
        role: updatedUser.role.name,
        department: updatedUser.department ? {
          id: updatedUser.department.id,
          name: updatedUser.department.name
        } : null
      }
    });
  } catch (error) {
    console.error('解除用户与角色关联失败:', error);
    return res.status(500).json({
      status: 'error',
      message: '解除用户与角色关联失败',
      error: error.message
    });
  }
};

/**
 * 重置用户密码
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.resetPassword = async (req, res) => {
  try {
    const { id } = req.params;
    const { password } = req.body;
    
    // 验证必填字段
    if (!password) {
      return res.status(400).json({
        status: 'error',
        message: '新密码为必填项'
      });
    }
    
    // 检查用户是否存在
    const user = await prisma.user.findUnique({
      where: { id: parseInt(id) }
    });
    
    if (!user) {
      return res.status(404).json({
        status: 'error',
        message: '用户不存在'
      });
    }
    
    // 加密新密码
    const hashedPassword = await bcrypt.hash(password, 10);
    
    // 更新用户密码
    await prisma.user.update({
      where: { id: parseInt(id) },
      data: { password: hashedPassword }
    });
    

    
    return res.json({
      status: 'success',
      message: '密码重置成功'
    });
  } catch (error) {
    console.error('重置密码失败:', error);
    return res.status(500).json({
      status: 'error',
      message: '重置密码失败',
      error: error.message
    });
  }
};

/**
 * 更新个人信息
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.updateProfile = async (req, res) => {
  try {
    const { id } = req.params;
    const { name, phone, oldPassword, password } = req.body;
    
    // 检查用户是否存在
    const user = await prisma.user.findUnique({
      where: { id: parseInt(id) }
    });
    
    if (!user) {
      return res.status(404).json({
        status: 'error',
        message: '用户不存在'
      });
    }
    
    // 准备更新数据
    const updateData = {};
    
    if (name) updateData.name = name;
    if (phone) updateData.phone = phone;
    
    // 如果要修改密码，需验证旧密码
    if (password) {
      if (!oldPassword) {
        return res.status(400).json({
          status: 'error',
          message: '修改密码需提供旧密码'
        });
      }
      
      // 验证旧密码
      const isPasswordValid = await bcrypt.compare(oldPassword, user.password);
      if (!isPasswordValid) {
        return res.status(400).json({
          status: 'error',
          message: '旧密码不正确'
        });
      }
      
      // 加密新密码
      updateData.password = await bcrypt.hash(password, 10);
    }
    
    // 更新用户信息
    const updatedUser = await prisma.user.update({
      where: { id: parseInt(id) },
      data: updateData,
      include: {
        role: true,
        department: true
      }
    });
    
    // 过滤掉敏感信息
    const { password: _, ...filteredUser } = updatedUser;
    
    return res.json({
      status: 'success',
      message: '个人信息更新成功',
      data: {
        ...filteredUser,
        role: updatedUser.role.name,
        department: updatedUser.department ? {
          id: updatedUser.department.id,
          name: updatedUser.department.name
        } : null
      }
    });
  } catch (error) {
    console.error('更新个人信息失败:', error);
    return res.status(500).json({
      status: 'error',
      message: '更新个人信息失败',
      error: error.message
    });
  }
}; 